Concurrent systems and inevitability

AbstractConcurrent systems viewed as partially ordered sets of states are considered. A property of system states is called inevitable, if the system will eventually reach a state with this property. This notion is discussed within the partial order framework

Constructing catalogue of temporal situations

Constructing catalogue of temporal situationsThe paper is aiming to create a common basis for description, comparing, and analysis natural languages. As a subject of comparison we have chosen temporal structures of some languages. For such a choice there exists a perfect tool, describing basic temporal phenomena, namely an ordering of states and events in time, certainty and uncertainty, independency of histories of separate objects, necessity and possibility. This tool is supported by the Petri nets formalism, which seems to be well suited for expressing the above mentioned phenomena. Petri nets are built form three primitive notions: of states, of events that begin or end the states, and so-called flow relation indicating succession of states and events. This simple constituents give rise to many possibilities of representing temporal phenomena; it turns out that such representations are sufficient for many (clearly, not necessarily all) temporal situations appearing in natural languages.In description formalisms used till now there is no possibility of expressing such reality phenomena as temporal dependencies in compound statement, or combination of temporality and modality. Moreover, using these formalisms one cannot distinguish between two different sources of uncertainty of the speaker while describing the reality: one, due to the lack of knowledge of the speaker what is going on in outside world, the second, due to objective impossibility of foreseen ways in which some conflict situations will be (or already have been) resolved. Petri net formalism seems to be perfectly suited for such differentiations.There are two main description principles that encompassed this paper. First, that assigns meaning to names of grammatical structures in different languages may lead to misunderstanding. Two grammatical structures with apparently close names may describe different reality. Additionally, some grammatical terms used in one language may be absent and not understandable in the other. It leads to assign meanings to situations, rather than to linguistic forms used for their expression. The second principle is limit the discussed issues to such a piece of reality that can be possible for precise description. The third is to avoid introducing such information to the described reality that is not explicitly mentioned by linguistic means. The authors try to following these principles in the present paper.The paper is organized as follows. First, some samples of situations related to present tense are given together with examples of their expressions in four languages: English, (as a reference language) and three Slavic languages, representing South slavonic languages (Bulgarian), West slavonic languages (Polish), and East slavonic languages (Russian). Within the same framework the next parts of the paper are constructed, supplying samples of using Past tenses and, finally, future tenses and modalities.The formal tools for description purposes are introduced stepwise, according to needs caused be the described reality. There are mainly Petri nets, equipped additionally with inscriptions or labeling in order to keep proper assignations of description units to described objects

Concurrent Computing with Shared Replicated Memory

The behavioural theory of concurrent systems states that any concurrent system can be captured by a behaviourally equivalent concurrent Abstract State Machine (cASM). While the theory in general assumes shared locations, it remains valid, if different agents can only interact via messages, i.e. sharing is restricted to mailboxes. There may even be a strict separation between memory managing agents and other agents that can only access the shared memory by sending query and update requests to the memory agents. This article is dedicated to an investigation of replicated data that is maintained by a memory management subsystem, whereas the replication neither appears in the requests nor in the corresponding answers. We show how the behaviour of a concurrent system with such a memory management can be specified using concurrent communicating ASMs. We provide several refinements of a high-level ground model addressing different replication policies and internal messaging between data centres. For all these refinements we analyse their effects on the runs such that decisions concerning the degree of consistency can be consciously made.Comment: 23 page

Locally Computable Enumerations

This paper is an extended and modified version of [10]. A protocol with local rules is presented for enumerating anonymous nodes of finite graphs. It is proved that such algorithms do not exists for the class of ambiguous graphs, defined in the paper; the proposed algorithm works successfully for remaining non-ambiguous graphs. It is also proved that protocol is fair, which means that no enumeration of nodes is discriminated by the protocol and that all individual nodes "know" the fact of successful termination of the protocol activity, provided the number of nodes of a graph is known to the protocol. The described protocol is a generalization of that presented in [9] by the author. Keywords: Algorithms; distributed systems; graphs; local computations 1 Introduction The issue of enumeration of nodes of a graph by local transformations is worth of consideration for a number of reasons. First, local transformations of graph labellings are good models of distributed computation, where re..

Distributed Enumeration

Finite, undirected graphs without self-loops are considered in the paper. The goal is to find a protocol for local computation which, starting with a uniform labelling of graph nodes, eventually terminates with a labelling being an enumeration of nodes. It is known from [4] that for some ("ambiguous") graphs of the considered family such a protocol does not exist; in the present paper a protocol is constructed which is the best in the sense that, for a given graph, it either enumerates nodes of the graph, or supplies a proof of ambiguity of the graph. It is proved that for any graph there exists a computation terminating with any a priori given enumeration of its nodes. It is also proved that after successful termination individual nodes "know" this fact. The proposed protocol can be used for election a leader out of nodes of graphs; in this way it generalizes existing algorithms. The protocol is called distributed, since remote nodes of the processed graph can communicate only by send..

Concurrent Program Schemes and their Interpretations

Schemes of concurrent programs are considered. The result of a scheme is defined as a set of traces, where each trace is a partially ordered set of symbol occurrences. It is shown that to each scheme corresponds a set of equations determining the result of the scheme; it is shown how these equations can be solved and that the solutions of these equations are regular trace languages. Next, a notion of action systems is introduced; an action consists of its resources and its transformation. Some properties of action systems are shown. Interpretations of schemes are defined as mappings which assign actions to scheme symbols. Interpreted schemes can be regarded as concurrent programs. It is shown how the results of schemes can be lifted (via interpretations) to the results of programs. Some examples of applications of the described methods to prove concurrent programs correct are given

Trace theory

The concept of traces has been introduced for describing non-sequential behaviour of concurrent systems via its sequential observations. Traces represent concurrent processes in the same way as strings represent sequential ones. The theory of traces can be used as a tool for reasoning about nets and it is hoped that applying this theory one can get a calculus of the concurrent processes anologous to that available for sequential systems. The following topics will be discussed: algebraic properties of traces, trace models of some concurrency phenomena, fixed-point calculus for finding the behaviour of nets, modularity, and some applications of the presented theory

Constructing catalogue of temporal situations

Constructing catalogue of temporal situationsThe paper is aiming to create a common basis for description, comparing, and analysis natural languages. As a subject of comparison we have chosen temporal structures of some languages. For such a choice there exists a perfect tool, describing basic temporal phenomena, namely an ordering of states and events in time, certainty and uncertainty, independency of histories of separate objects, necessity and possibility. This tool is supported by the Petri nets formalism, which seems to be well suited for expressing the above mentioned phenomena. Petri nets are built form three primitive notions: of states, of events that begin or end the states, and so-called flow relation indicating succession of states and events. This simple constituents give rise to many possibilities of representing temporal phenomena; it turns out that such representations are sufficient for many (clearly, not necessarily all) temporal situations appearing in natural languages.In description formalisms used till now there is no possibility of expressing such reality phenomena as temporal dependencies in compound statement, or combination of temporality and modality. Moreover, using these formalisms one cannot distinguish between two different sources of uncertainty of the speaker while describing the reality: one, due to the lack of knowledge of the speaker what is going on in outside world, the second, due to objective impossibility of foreseen ways in which some conflict situations will be (or already have been) resolved. Petri net formalism seems to be perfectly suited for such differentiations.There are two main description principles that encompassed this paper. First, that assigns meaning to names of grammatical structures in different languages may lead to misunderstanding. Two grammatical structures with apparently close names may describe different reality. Additionally, some grammatical terms used in one language may be absent and not understandable in the other. It leads to assign meanings to situations, rather than to linguistic forms used for their expression. The second principle is limit the discussed issues to such a piece of reality that can be possible for precise description. The third is to avoid introducing such information to the described reality that is not explicitly mentioned by linguistic means. The authors try to following these principles in the present paper.The paper is organized as follows. First, some samples of situations related to present tense are given together with examples of their expressions in four languages: English, (as a reference language) and three Slavic languages, representing South slavonic languages (Bulgarian), West slavonic languages (Polish), and East slavonic languages (Russian). Within the same framework the next parts of the paper are constructed, supplying samples of using Past tenses and, finally, future tenses and modalities.The formal tools for description purposes are introduced stepwise, according to needs caused be the described reality. There are mainly Petri nets, equipped additionally with inscriptions or labeling in order to keep proper assignations of description units to described objects

Labelled (hyper)graphs, negotiations and the naming problem

International audienceWe consider four different models of process interactions that unify and generalise models introduced and studied by Angluin et al. and models introduced and studied by Mazurkiewicz. We encode these models by labelled (hyper)graphs and relabelling rules on this labelled (hyper)graphs called negotiations. Then for these models, we give complete characterisations of labelled graphs in which the naming problem can be solved. Our characterizations are expressed in terms of locally constrained homomorphisms that are generalisations of known graph homomorphisms